{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用NER&Denpendency Prasing对句子进行解析 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 句子依存关系解析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分析步骤：\n",
    "1. 把文章切断成句子\n",
    "2. 对条句子进行分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import Column, String, create_engine\n",
    "from sqlalchemy.orm import sessionmaker\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.sql import select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "passward = '###'\n",
    "host = '###'\n",
    "user = 'root'\n",
    "post = '3306'\n",
    "database = 'stu_db'\n",
    "engine= create_engine(\"mysql+mysqlconnector://{}:{}@{}:{}/{}\".format(user,passward,host,post,database))\n",
    "connection = engine.connect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_list = connection.execute(\"select id from news_chinese\")\n",
    "id_list = id_list.fetchall()\n",
    "content_list = connection.execute(\"select content from news_chinese\")\n",
    "content_list = content_list.fetchall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "命名实体识别标注集:\n",
    "- 标记 =\t含义\n",
    "- O =\t这个词不是NE\n",
    "- S =\t这个词单独构成一个NE\n",
    "- B =\t这个词为一个NE的开始\n",
    "- I =\t这个词为一个NE的中间\n",
    "- E =\t这个词位一个NE的结尾\n",
    "- Nh =\t人名\n",
    "- Ni =\t机构名\n",
    "- Ns =\t地名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用依存句法分析找出观点的内容，以下代码是测试时候方便调试的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     8,
     15,
     21,
     27,
     35,
     42,
     46,
     51,
     64
    ]
   },
   "outputs": [],
   "source": [
    "from pyltp import Segmentor\n",
    "from pyltp import Postagger\n",
    "from pyltp import NamedEntityRecognizer\n",
    "from pyltp import SentenceSplitter\n",
    "from pyltp import Parser\n",
    "import os\n",
    "\n",
    "#分句\n",
    "def cut_sentence(string):\n",
    "    \"\"\"@string contain many sentence\"\"\"\n",
    "    from pyltp import SentenceSplitter\n",
    "    sents = SentenceSplitter.split(string)  # 分句\n",
    "    return list(sents)\n",
    "    \n",
    "#分词\n",
    "def cut_word(sentence,model):\n",
    "    \"\"\"@sentence is a string\"\"\"\n",
    "    words = model.segment(sentence)  # 分词\n",
    "    return list(words)\n",
    "\n",
    "#词信标注\n",
    "def pos_label(words, mdoel):\n",
    "    \"\"\"@words is a list result of cut word\"\"\"\n",
    "    postags = mdoel.postag(words)  # 词性标注\n",
    "    return list(postags)\n",
    "\n",
    "#命名实体识别\n",
    "def ner_label(words, postags, model):\n",
    "    \"\"\"@words is a list  result of cut word\n",
    "       @postags is a list result of Part-Of-Speech tagging\n",
    "    \"\"\"\n",
    "    netags = model.recognize(words, postags)  # 命名实体识别\n",
    "    return list(netags)\n",
    "\n",
    "#依存句法分析\n",
    "def dependency_parsing(words, postags, model):\n",
    "    \"\"\"@words is a list  result of cut word\n",
    "       @postags is a list result of Part-Of-Speech tagging\n",
    "    \"\"\" \n",
    "    arcs = model.parse(words, postags)  # 句法分析\n",
    "    return list(arcs)\n",
    "\n",
    "def find_word_index(word,words):\n",
    "    for i in range(len(words)):\n",
    "        if words[i] == word:\n",
    "            return i\n",
    "def find_head(den_parsing_list):\n",
    "    for i in range(len(den_parsing_list)):\n",
    "        if den_parsing_list[i].head == 0:\n",
    "            return i\n",
    "\n",
    "def search_index(start, den_parsing_list,word_list):\n",
    "    tree_dict = {word_list[start]:{}}\n",
    "    j=0\n",
    "    for i,arc in enumerate(den_parsing_list):\n",
    "        if arc.head == start+1:\n",
    "            j +=1\n",
    "            tree_dict[word_list[start]][word_list[i]] = \\\n",
    "            search_index(i,den_parsing_list,word_list)\n",
    "    if j==0:return word_list[start]\n",
    "    return tree_dict  \n",
    "\n",
    "from collections import defaultdict\n",
    "#该函数找出树形结构关系，并返回关系，层数和最大宽度，方便图绘制\n",
    "def search_find_dict(start, den_parsing_list,word_list_orgin):\n",
    "    word_list = []\n",
    "    #对重复词进行重新编号，以区别\n",
    "    for i,word in enumerate(word_list_orgin):\n",
    "        if word in word_list:\n",
    "            word_list.append(word+'_'+str(i))\n",
    "        else:\n",
    "            word_list.append(word)\n",
    "            \n",
    "    tree_dict = defaultdict(list)\n",
    "    \n",
    "    current_layer = 0\n",
    "    length = len(start)\n",
    "    max_length = 0\n",
    "    while start!= []:\n",
    "        current_p = start.pop(0)\n",
    "        length -= 1 \n",
    "        for i,arc in enumerate(den_parsing_list):\n",
    "            if arc.head == current_p+1:\n",
    "                start.append(i)\n",
    "                tree_dict[word_list[current_p]] += [[word_list[i],arc.relation]]\n",
    "        #当遍历到下一层时\n",
    "        if length == 0:\n",
    "            current_layer +=1\n",
    "            length = len(start)\n",
    "            if max_length < length:\n",
    "                max_length = length\n",
    "    return tree_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def pretty_print(word_list, ner_list):   \n",
    "    import math\n",
    "    num = math.ceil(len(word_list)/14)\n",
    "    index = range(1, len(word_list)+1)\n",
    "    for line_num in range(num):\n",
    "        str1 = ''\n",
    "        str2 = ''\n",
    "        str3 = ''\n",
    "        if line_num == num -1:\n",
    "            word_temp = word_list[line_num*14:]\n",
    "            ner_temp = ner_list[line_num*14:]\n",
    "            index_temp = index[line_num*14:]\n",
    "        else:\n",
    "            word_temp = word_list[line_num*14:(line_num+1)*14]\n",
    "            ner_temp = ner_list[line_num*14:(line_num+1)*14]   \n",
    "            index_temp = index[line_num*14:(line_num+1)*14]\n",
    "        for i, j in zip(word_temp, ner_temp):\n",
    "            i_len = len(i)\n",
    "            j_len = len(j)\n",
    "            if i_len > 5:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t\\t|'\n",
    "                str3 += '{}\\t\\t|'\n",
    "            else:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t|'\n",
    "                str3 += '{}\\t|'\n",
    "        print(str3.format(*index_temp))\n",
    "        print(str1.format(*word_temp))\n",
    "        print(str2.format(*ner_temp),'\\n')\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['font.sans-serif']= ['SimHei']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "自定义个绘制了依存句法关系的模块：\n",
    "\n",
    "模块在plottree.plottree 里的 createPlot方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "去掉标点，对比一下结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 针对说等次词，找出其宾语即说的内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "#输入显示调整函数\n",
    "def pretty_print(word_list, ner_list):   \n",
    "    import math\n",
    "    num = math.ceil(len(word_list)/14)\n",
    "    index = range(1, len(word_list)+1)\n",
    "    for line_num in range(num):\n",
    "        str1 = ''\n",
    "        str2 = ''\n",
    "        str3 = ''\n",
    "        if line_num == num -1:\n",
    "            word_temp = word_list[line_num*14:]\n",
    "            ner_temp = ner_list[line_num*14:]\n",
    "            index_temp = index[line_num*14:]\n",
    "        else:\n",
    "            word_temp = word_list[line_num*14:(line_num+1)*14]\n",
    "            ner_temp = ner_list[line_num*14:(line_num+1)*14]   \n",
    "            index_temp = index[line_num*14:(line_num+1)*14]\n",
    "        for i, j in zip(word_temp, ner_temp):\n",
    "            i_len = len(i)\n",
    "            j_len = len(j)\n",
    "            if i_len > 5:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t\\t|'\n",
    "                str3 += '{}\\t\\t|'\n",
    "            else:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t|'\n",
    "                str3 += '{}\\t|'\n",
    "        print(str3.format(*index_temp))\n",
    "        print(str1.format(*word_temp))\n",
    "        print(str2.format(*ner_temp),'\\n')\n",
    "        \n",
    "def table_print(word_list, ner_list):\n",
    "    import prettytable as pt\n",
    "    tb = pt.PrettyTable()\n",
    "    tb.add_column('1',word_list)\n",
    "    tb.add_column('2',ner_list)\n",
    "    print(tb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "code_folding": [
     14,
     40,
     49,
     56,
     67,
     74,
     80,
     107,
     185
    ]
   },
   "outputs": [],
   "source": [
    "##完成项目代码\n",
    "from collections import defaultdict\n",
    "from pyltp import Segmentor\n",
    "from pyltp import Postagger\n",
    "from pyltp import NamedEntityRecognizer\n",
    "from pyltp import SentenceSplitter\n",
    "from pyltp import Parser\n",
    "from gensim.models import KeyedVectors\n",
    "import numpy as np\n",
    "import jieba\n",
    "import os\n",
    "import time\n",
    "from collections import Counter\n",
    "\n",
    "def get_sentences_vec(model_wv, sent_list, word_frequence):\n",
    "    # 句子向量化处理\n",
    "    a = 0.001\n",
    "    row = model_wv.vector_size\n",
    "    col = len(sent_list)\n",
    "    sent_mat = np.zeros((row, col))\n",
    "    for i, sent in enumerate(sent_list):\n",
    "        length = len(sent)\n",
    "        sent_vec = np.zeros(row)\n",
    "        for word in sent:\n",
    "            pw = word_frequence[word]\n",
    "            w = a / (a + pw)\n",
    "            try:\n",
    "                vec = np.array(model_wv[word])\n",
    "                sent_vec += w * vec\n",
    "            except:\n",
    "                pass\n",
    "        sent_mat[:, i] += sent_vec\n",
    "        sent_mat[:, i] /= length\n",
    "\n",
    "    # PCA处理\n",
    "    sent_mat = np.mat(sent_mat)\n",
    "    u, s, vh = np.linalg.svd(sent_mat)\n",
    "    sent_mat = sent_mat - u * u.T * sent_mat\n",
    "    return sent_mat\n",
    "\n",
    "def get_word_frequence(words):\n",
    "    #这里不做停用次处理，直接在计算句子向量时候，如果找不到该词，直接跳过\n",
    "    word_list = []\n",
    "    for word in words:\n",
    "        word_list += word\n",
    "    word_frequence = Counter(word_list)\n",
    "    return word_frequence\n",
    "\n",
    "# 计算余弦相似度\n",
    "def cos_similarity(v1, v2):\n",
    "    #输入向量维度不一致\n",
    "    if len(v1) != len(v2):\n",
    "        return 0\n",
    "    return np.vdot(v1,v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))\n",
    "\n",
    "# 返回句子向量矩阵中各列向量与第一列向量的相似度\n",
    "def calcu_similarity(sent_mat):\n",
    "    #采用点积的方法计算\n",
    "    first = np.array(sent_mat[:, 0]).flatten()\n",
    "    col = sent_mat.shape[1]\n",
    "    sims = []\n",
    "    for i in range(1, col):\n",
    "        vec = np.array(sent_mat[:, i]).flatten()\n",
    "        sims.append(cos_similarity(first, vec))\n",
    "    return sims\n",
    "\n",
    "#获取相似度结果\n",
    "def get_similarity_result(word_list_all, model_wv):\n",
    "    word_frequence = get_word_frequence(word_list_all)\n",
    "    sent_mat = get_sentences_vec(model_wv, word_list_all,word_frequence)\n",
    "    sim = calcu_similarity(sent_mat)\n",
    "    return sim\n",
    "\n",
    "#分句\n",
    "def cut_sentence(string):\n",
    "    \"\"\"@string contain many sentence\"\"\"\n",
    "    from pyltp import SentenceSplitter\n",
    "    sents = SentenceSplitter.split(string)  # 分句\n",
    "    return list(sents)\n",
    "\n",
    "def load_all_model():\n",
    "    \"\"\"返回分词，词性标注，命名实体识别，依存解析等实例对象\"\"\"\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    cws_model_path = os.path.join(LTP_DATA_DIR, 'cws.model')  # 分词模型路径，模型名称为`cws.model`\n",
    "    segmentor = Segmentor()  # 初始化实例\n",
    "    segmentor.load_with_lexicon(cws_model_path, '../ltp_data/cut_external_dict/cut_external_dict')  # 加载模型\n",
    "    \n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    pos_model_path = os.path.join(LTP_DATA_DIR, 'pos.model')  # 词性标注模型路径，模型名称为`pos.model`\n",
    "    postagger = Postagger() # 初始化实例\n",
    "    postagger.load_with_lexicon(pos_model_path, '../ltp_data/pos_external_dict/pos_external_dict')  # 加载模型\n",
    "\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    ner_model_path = os.path.join(LTP_DATA_DIR, 'ner.model')  # 命名实体识别模型路径，模型名称为`pos.model`\n",
    "    recognizer = NamedEntityRecognizer() # 初始化实例\n",
    "    recognizer.load(ner_model_path)  # 加载模型\n",
    "\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    par_model_path = os.path.join(LTP_DATA_DIR, 'parser.model')  # 依存句法分析模型路径，模型名称为`parser.model`   \n",
    "    parser = Parser() # 初始化实例\n",
    "    parser.load(par_model_path)  # 加载模型\n",
    "    \n",
    "    fname = r\"E:/MYGIT/model/wiki_stopwords/wiki_word2vec.kv\"\n",
    "    #model_wv.save(fname)\n",
    "    model_wv = KeyedVectors.load(fname, mmap='r')\n",
    "    return [segmentor, postagger, recognizer, parser,model_wv]\n",
    "\n",
    "def release_all_model(model_list):\n",
    "    del(model_list[-1])\n",
    "    for each in model_list:\n",
    "        each.release()\n",
    "\n",
    "#获取人名或机构名\n",
    "def get_name(word_list, prase, ner_list, pos_list,say_index):\n",
    "    # 合并说话对象名字\n",
    "    index = -1\n",
    "    for arc in prase:\n",
    "        if arc.relation == \"SBV\" and arc.head == say_index + 1:\n",
    "            index = prase.index(arc)\n",
    "            #break\n",
    "            # 第二种情况\n",
    "    if index == -1:\n",
    "        for arc in prase:\n",
    "            if arc.relation == \"SBV\" and arc.head == prase[say_index].head and prase[say_index].relation == \"COO\":\n",
    "                index = prase.index(arc)\n",
    "    # 两种情况都没找到\n",
    "    if index == -1: return ''\n",
    "\n",
    "    Entity = ('S-Nh', 'S-Ni', 'S-Ns','B-Nh', 'B-Ni','B-Ns', 'I-Nh', 'I-Ni','I-Ns', 'E-Nh', 'E-Ni','E-Ns')  # 命名实体标记\n",
    "    #Entity = ('S-Nh', 'S-Ni')  # 命名实体标记\n",
    "    name = ''\n",
    "    cur = index\n",
    "    ret_flag = False\n",
    "    while cur >= 0:\n",
    "        if ner_list[cur] in Entity or cur == index:\n",
    "            name = word_list[cur] + name   \n",
    "            if ner_list[cur] in Entity:ret_flag = True\n",
    "            cur -= 1\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    if ret_flag:return name\n",
    "    if pos_list[index] not in ('n', 'nh', 'ws'): return ''\n",
    "    \n",
    "    pre = word_list[:index]  # 前半部分\n",
    "    pos = word_list[index + 1:]  # 后半部分\n",
    "    while pre:\n",
    "        w = pre.pop(-1)\n",
    "        w_index = word_list.index(w)\n",
    "        # if prase[w_index].relation == 'ADV': continue\n",
    "        if prase[w_index].relation in ('WP', 'ATT', 'SVB') and (w not in ('，','。','、','）','（')):\n",
    "            name = w + name\n",
    "        else:\n",
    "            pre = False\n",
    "    while pos:\n",
    "        w = pos.pop(0)\n",
    "        w_index = word_list.index(w)\n",
    "        if prase[w_index].head - 1 == index or \\\n",
    "                prase[prase[w_index].head - 1].head - 1 == index or \\\n",
    "                prase[prase[prase[w_index].head - 1].head - 1].head - 1 == index:\n",
    "            if prase[w_index].relation in ('WP', 'LAD', 'COO', 'RAD', 'ATT') and w_index < say_index and (\n",
    "                    w not in ('，', '。', '、', '）', '（')):\n",
    "                name = name + w  # 向后拼接\n",
    "            else:  # 中断拼接直接返回\n",
    "                pos = False\n",
    "        else:\n",
    "            pos = False\n",
    "    return name \n",
    " \n",
    "def get_under_node(parent_node, parse, relation):\n",
    "    index = []\n",
    "    for arc in parse:\n",
    "        if arc.relation == relation and arc.head == parent_node +1:\n",
    "            index.append(parse.index(arc))\n",
    "    try:\n",
    "        return index\n",
    "    except NameError:\n",
    "        return -1 \n",
    "    \n",
    "#找出输入所有节点中最小的索引和最大的索引，然后返回两者间的句子\n",
    "def node_under_sentence(parent_point, den_parsing_list, word_list):    \n",
    "    words_index = []\n",
    "    #搜索子节点\n",
    "    if parent_point == [] or parent_point[0] < 0 :return ''\n",
    "    for point in parent_point:\n",
    "        start = [point]\n",
    "        words_index.append(start[0])\n",
    "        while start!= []:\n",
    "            cur = start.pop(0)\n",
    "            for i, arc in enumerate(den_parsing_list):\n",
    "                if arc.head == cur + 1:\n",
    "                    words_index.append(i)\n",
    "                    start.append(i)\n",
    "    words_index = sorted(words_index)\n",
    "    #print(words_index, len(word_list))\n",
    "    return ''.join(word_list[words_index[0]:words_index[-1]+1])\n",
    "\n",
    "#从文件中提取与说相关的词\n",
    "def get_relatedwords():\n",
    "    path  = 'E:/MYGIT/Project/NLP-Project-1/related_words/saywords'\n",
    "    relatedwords_list = []\n",
    "    with open(path, encoding='utf-8') as f:\n",
    "        line_str= f.readline()\n",
    "        while line_str  != '':\n",
    "            relatedwords_list.append(line_str.strip('\\n'))\n",
    "            line_str = f.readline()\n",
    "    relatedwords_list = tuple(relatedwords_list)\n",
    "    return relatedwords_list\n",
    "\n",
    "def find_opinion_of_someone(input_news, say_related, model_list):\n",
    "    # 输入文本进行分句\n",
    "    segmentor = model_list[0]\n",
    "    postagger = model_list[1]\n",
    "    recognizer= model_list[2]\n",
    "    parser= model_list[3]\n",
    "    model_wv = model_list[4]\n",
    "\n",
    "    sentence_list = cut_sentence(input_news)\n",
    "    sentence_list = [sen for sen in sentence_list if len(sen) > 3]\n",
    "    Entity = ['S-Nh', 'S-Ni','B-Nh', 'B-Ni', 'I-Nh', 'I-Ni', 'E-Nh', 'E-Ni']  # 命名实体标记\n",
    "    pro_news_dict = defaultdict(list) #用来存储可能是多句的句子\n",
    "    news_dict = defaultdict(list)\n",
    "    \n",
    "    word_list_all = [list(segmentor.segment(sentence)) for sentence in sentence_list]  # 分词\n",
    "    #name_list = [] #用于保存所有人名\n",
    "    for _i, sentence in enumerate(sentence_list):\n",
    "        #print('\\n——————————句子:{} 处理过程——————————'.format(_i + 1))\n",
    "        #time_point_1 = time.time()\n",
    "        word_list = word_list_all[_i]  #     \n",
    "        pos_list = list(postagger.postag(word_list))  # 词性分析\n",
    "        ner_list = list(recognizer.recognize(word_list, pos_list))  # 命名实体提取\n",
    "        den_parsing_list = list(parser.parse(word_list, pos_list))  # 依存关系\n",
    "                       \n",
    "        # 获取命名实体和说相关词,同时获取索引值\n",
    "        pro_say_word = [(a, i) for i, a in enumerate(word_list) if a in say_related]  \n",
    "        if pro_say_word==[]:continue\n",
    "        \n",
    "        # 找到说的主语\n",
    "        for say in pro_say_word:\n",
    "            if say[0] in (':','：') and den_parsing_list[say[1]].relation == 'WP':\n",
    "                say = (say[0], den_parsing_list[say[1]].head-1)\n",
    "            name = get_name(word_list, den_parsing_list, ner_list, pos_list, say[1])\n",
    "            #print('第{}句子, sayword:{} name:{}'.format(_i, say, name))\n",
    "            if name != '':\n",
    "                say_underword = []\n",
    "                index = get_under_node(say[1], den_parsing_list, 'VOB')           \n",
    "                if index != -1: \n",
    "                    _flag = len(index)\n",
    "                    say_underword += index\n",
    "                    index = get_under_node(say[1], den_parsing_list, 'COO')\n",
    "                    if index != -1: say_underword += index\n",
    "                        \n",
    "                #特殊情况处理1\n",
    "                if len(say_underword) > _flag:\n",
    "                    for _node in range(_flag):\n",
    "                        if pos_list[say_underword[_node]] in ['n','nh']:\n",
    "                            say_underword.pop(0)\n",
    "                \n",
    "                #特殊情况处理2\n",
    "                saying = node_under_sentence(say_underword, den_parsing_list, word_list)\n",
    "                if not saying:\n",
    "                    if (den_parsing_list[say[1]].relation =='POB' and den_parsing_list[den_parsing_list[say[1]].head-1].relation == 'ADV'):\n",
    "                        saying = ''.join(word_list[say[1]+1:])\n",
    "                        saying = saying.strip('，')\n",
    "                    if not saying:\n",
    "                        if _i>0:\n",
    "                            quotations = re.findall(r'“(.+?)”', sentence_list[_i-1])\n",
    "                            if quotations and len(quotations[-1])> 6: saying = quotations[-1]\n",
    "                if saying != '':\n",
    "                    if saying[-5:] in sentence[-9:]:\n",
    "                        words1 = jieba.lcut(saying)\n",
    "                        _word_list = sentence_list[_i+1:_i+4] #切片的话_i+4如果超出则取到末尾\n",
    "                        _word_list.insert(0, words1)\n",
    "                        sim = get_similarity_result(_word_list, model_wv)\n",
    "                        #print(sim)\n",
    "                        for i_sim, _sim in enumerate(sim):\n",
    "                            if _sim > 0.85:\n",
    "                                pro_news_dict[_i] += [sentence_list[_i + i_sim+1]]\n",
    "                            else:\n",
    "                                break\n",
    "                    news_dict[_i] = [name, say[0], saying]\n",
    "                    break  \n",
    "    \n",
    "    #对多句添加进行判断，如果下一句里没说，或没提取出来，则拼接到上一句，避免重复\n",
    "    for key in pro_news_dict.keys():\n",
    "        for _i in range(len(pro_news_dict[key])):\n",
    "            if key+_i+1 not in news_dict.keys():\n",
    "                news_dict[key][1] += pro_news_dict[key][_i]\n",
    "            else:\n",
    "                break \n",
    "    return news_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上提取程序还未解决以下特殊情况:\n",
    "- line1：\"###########言论########\"\n",
    "- line2：某某说，##############\n",
    "\n",
    "在这种情况中，line1也是某某说的话，该程序只提取到了line2后面的话"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试提取效果，用以改进提取算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import re\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 328 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "relatedwords_list = get_relatedwords()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#获取测试新闻\n",
    "news_path = r'E:/MYGIT/DataSources/THUCNews/news_origin/社会新闻_all.txt'\n",
    "news_list = []\n",
    "with open(news_path, encoding='utf-8') as f:\n",
    "    for i in range(10000):\n",
    "        line_str = f.readline()\n",
    "        if line_str == '': break\n",
    "        if line_str.startswith('视频') or line_str.startswith('调查') or len(line_str)>1500: continue\n",
    "        news_list.append(line_str.strip('\\n'))\n",
    "#news_list[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "':' in relatedwords_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'：' in relatedwords_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Design Software\\Anaconda\\envs\\py36\\lib\\site-packages\\smart_open\\smart_open_lib.py:398: UserWarning: This function is deprecated, use smart_open.open instead. See the migration notes for details: https://github.com/RaRe-Technologies/smart_open/blob/master/README.rst#migrating-to-the-new-open-function\n",
      "  'See the migration notes for details: %s' % _MIGRATION_NOTES_URL\n"
     ]
    }
   ],
   "source": [
    "model_list = load_all_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'test' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-4e1243bd22c6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'test' is not defined"
     ]
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "release_all_model(model_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = random.choice(news_list)\n",
    "test = test.replace('\\u3000','')\n",
    "test = test.replace('\\\\n','')\n",
    "#test += sen\n",
    "sentence_list = cut_sentence(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "sen = '''IG Markets高级分析师DanCook说，“我最大的忧虑是如果消费者失业或没有钱消费，无论消费者如何乐观都变得不重要'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\Oliver\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "front\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 0.936 seconds.\n",
      "Prefix dict has been built succesfully.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defaultdict(list, {0: ['其家人', '介绍', '小涛的爷爷听说用纯碱水洗酒坛很管用']})"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_opinion_of_someone(sen[1],relatedwords_list,model_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第1句: 地震生死恋人将在北京台春晚完婚本报讯（记者 龙露）今天上午，北京电视台春晚总导演齐建彤宣布，从四川大地震中走出来的一对新人贺晨曦、郑广明将在春节联欢晚会上举行他们的婚礼。\n",
      "第2句: 上午，海淀区新贵大厦二层大宅门餐厅内红灯高挂、北侧的小舞台上布满了鲜花，一对由数百朵红玫瑰组成的两颗“心形”花环紧紧重叠在一起。\n",
      "第3句: 11时，在《童话》悠扬的音乐声中，一对新人贺晨曦、郑广明踏着红地毯穿过花门走上舞台，举行了订婚仪式，新娘贺晨曦身穿蓝色晚礼服，脸上洋溢着幸福的笑容。\n",
      "第4句: 在场的志愿者对新人表达了真情的祝福，餐厅的220名服务员每人捐出了一元钱表达了220个对新人的祝福。\n",
      "第5句: 据介绍，准新郎郑广明来自东北，到四川打工时认识了四川姑娘贺晨曦。\n",
      "第6句: 在四川大地震时，贺晨曦被压在废墟下104个小时。\n",
      "第7句: 当她被救出后，一直昏迷不醒，见此，郑广明不断对她呼唤：你快醒来吧，醒来，我们马上结婚。\n",
      "第8句: 在郑广明爱的呼唤下，贺晨曦终于脱离了危险。\n",
      "第9句: 大地震后，家没了，工作也没了，两人只好挤在一间几平方米的小屋内，仅靠郑广明打工赚到的一点钱维持生计，结婚却成了两人暂时无法完成的一个“梦”。\n",
      "第10句: 北京电视台《真情耀中华》栏目的工作人员得知这个情况后，号召志愿者及所有北京市民共同帮助贺晨曦、郑广明完成这个婚礼。\n",
      "第11句: 12月10日，志愿者从北京出发了。\n",
      "第12句: 15日，两人被接到了北京，北京的志愿者不但为两人定好下榻的酒店，还帮他们定好了订婚的餐厅。\n",
      "第13句: 更多的北京市民打来电话，愿意为两人提供婚车、礼服。\n",
      "第14句: 北京电视台春节联欢晚会总导演齐建彤介绍，贺晨曦、郑广明的正式婚礼要在大年三十的春晚联欢会上举办，我们要为这对新人举办一场盛大的婚礼。\n",
      "第15句: 此外，齐建彤还透露，《真情耀中华》栏目的明星志愿者——电影演员刘烨通过栏目组转来了为新人祝福的红包。\n",
      "第16句: 孙妍 摄\n"
     ]
    }
   ],
   "source": [
    "for _a, i in enumerate(sentence_list):\n",
    "    print('第{}句: {}'.format(_a+1, i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sentence_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#该模块是自己编写的，为了方便观察依存关系树\n",
    "from plottree import plottree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "sen = ['IG Markets高级分析师DanCook说，“我最大的忧虑是如果消费者失业或没有钱消费，无论消费者如何乐观都变得不重要',\n",
    "'''据其家人介绍，小涛的爷爷听说用纯碱水洗酒坛很管用''',\n",
    "'''李某某称，其销售的生羊合格。''',\n",
    "'''单霁翔再次重申：“中国政府高度重视和关心流失海外中国文物的问题''',\n",
    "'''单霁翔说，中国文物流失时间跨度较大''',\n",
    "      '中共中央总书记习近平表示，要加强基础建设',\n",
    "      '据合肥一些玩家透露，目前，我省淮南、淮北一带的一些煤老板也投身“石海”。他们动辄花上百万、千万从一些个人玩家手上收集玉器',\n",
    "      '虚幻引擎3动作游戏《黑光》新作公布曾经开发过多款大受好评电脑军事游戏的美国Zombie Studios公司，日前宣布与福克斯电影合作']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word_list = cut_word(sentence_list[0], model_list[0])\n",
    "word_list = cut_word(sen[-1], model_list[0])\n",
    "pos_list = pos_label(word_list, model_list[1])\n",
    "ner_list = ner_label(word_list,pos_list,model_list[2])\n",
    "den_parsing_list = dependency_parsing(word_list,pos_list,model_list[3])\n",
    "dp_list = [str(arc.head) + ':'+ arc.relation for arc in den_parsing_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\t|2\t|3\t|4\t|5\t|6\t|7\t|8\t|9\t|10\t|11\t|12\t|13\t|14\t|\n",
      "据\t|合肥\t|一些\t|玩家\t|透露\t|，\t|目前\t|，\t|我省\t|淮南\t|、\t|淮北\t|一带\t|的\t|\n",
      "O\t|S-Ns\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|S-Ns\t|O\t|S-Ns\t|O\t|O\t| \n",
      "\n",
      "15\t|16\t|17\t|18\t|19\t|20\t|21\t|22\t|23\t|24\t|25\t|26\t|27\t|28\t|\n",
      "一些\t|煤\t|老板\t|也\t|投身\t|“\t|石海\t|”\t|。\t|他们\t|动辄\t|花\t|上\t|百万\t|\n",
      "O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t| \n",
      "\n",
      "29\t|30\t|31\t|32\t|33\t|34\t|35\t|36\t|37\t|\n",
      "、\t|千万\t|从\t|一些\t|个人\t|玩家\t|手上\t|收集\t|玉器\t|\n",
      "O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t| \n",
      "\n"
     ]
    }
   ],
   "source": [
    "pretty_print(word_list, ner_list)\n",
    "#pretty_print(word_list, pos_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'合肥一些玩家'"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_name(word_list, den_parsing_list, ner_list, pos_list, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "relation_dict = search_find_dict([find_head(den_parsing_list)],den_parsing_list, word_list)\n",
    "start = word_list[find_head(den_parsing_list)]\n",
    "plottree.createPlot(start, relation_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 确定言论结束"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sentence Embedding-基础词向量的句子向量化处理"
   ]
  },
  {
   "attachments": {
    "%E5%9B%BE%E7%89%87.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![%E5%9B%BE%E7%89%87.png](attachment:%E5%9B%BE%E7%89%87.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- line2：计算每条句子的向量，以列存储 原文是 compute the weighted average of the word vector\n",
    "- line6：原文是 remove the projections of the average vectors on their first singular verctor(common component removal),至于为什么line6这样计算会是common component removal，还没弄明白，有空再深究\n",
    "- 最后得到的矩阵是M×N的 M为词向量维度，N为句子个数，可以看出每个句子向量都是以列保存的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Design Software\\Anaconda\\envs\\py36\\lib\\site-packages\\smart_open\\smart_open_lib.py:398: UserWarning: This function is deprecated, use smart_open.open instead. See the migration notes for details: https://github.com/RaRe-Technologies/smart_open/blob/master/README.rst#migrating-to-the-new-open-function\n",
      "  'See the migration notes for details: %s' % _MIGRATION_NOTES_URL\n"
     ]
    }
   ],
   "source": [
    "fname = r\"E:/MYGIT/model/wiki_stopwords/wiki_word2vec.kv\"\n",
    "#model_wv.save(fname)\n",
    "model_wv = KeyedVectors.load(fname, mmap='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "code_folding": [
     4
    ]
   },
   "outputs": [],
   "source": [
    "from gensim.models import KeyedVectors\n",
    "import logging\n",
    "\n",
    "#该函数对应的是上诉图片中伪代码的实现过程\n",
    "def get_sentences_vec(model_wv, sent_list, word_frequence):\n",
    "    # 句子向量化处理\n",
    "    a = 0.001\n",
    "    row = model_wv.vector_size\n",
    "    col = len(sent_list)\n",
    "    sent_mat = np.zeros((row, col))\n",
    "    for i, sent in enumerate(sent_list):\n",
    "        length = len(sent)\n",
    "        sent_vec = np.zeros(row)\n",
    "        for word in sent:\n",
    "            pw = word_frequence[word]\n",
    "            w = a / (a + pw)\n",
    "            try:\n",
    "                vec = np.array(model_wv[word])\n",
    "                sent_vec += w * vec\n",
    "            except:\n",
    "                pass\n",
    "        sent_mat[:, i] += sent_vec\n",
    "        sent_mat[:, i] /= length\n",
    "\n",
    "    # PCA处理\n",
    "    sent_mat = np.mat(sent_mat)\n",
    "    u, s, vh = np.linalg.svd(sent_mat)\n",
    "    sent_mat = sent_mat - u * u.T * sent_mat\n",
    "    return sent_mat\n",
    "\n",
    "def get_word_frequence(words):\n",
    "    #这里不做停用次处理，直接在计算句子向量时候，如果找不到该词，直接跳过\n",
    "    word_list = []\n",
    "    for word in words:\n",
    "        word_list += word\n",
    "    word_frequence = Counter(word_list)\n",
    "    return word_frequence\n",
    "\n",
    "# 计算余弦相似度\n",
    "def cos_similarity(v1, v2):\n",
    "    #输入向量维度不一致\n",
    "    if len(v1) != len(v2):\n",
    "        return 0\n",
    "    return np.vdot(v1,v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))\n",
    "\n",
    "# 返回句子向量矩阵中各列向量与第一列向量的相似度\n",
    "def calcu_similarity(sent_mat):\n",
    "    #采用点积的方法计算\n",
    "    first = np.array(sent_mat[:, 0]).flatten()\n",
    "    col = sent_mat.shape[1]\n",
    "    sims = []\n",
    "    for i in range(1, col):\n",
    "        vec = np.array(sent_mat[:, i]).flatten()\n",
    "        sims.append(cos_similarity(first, vec))\n",
    "    return sims\n",
    "\n",
    "#获取相似度结果\n",
    "def get_similarity_result(word_list_all, model_wv):\n",
    "    word_frequence = get_word_frequence(word_list_all)\n",
    "    sent_mat = get_sentences_vec(model_wv, word_list_all,word_frequence)\n",
    "    sim = calcu_similarity(sent_mat)\n",
    "    return sim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 使用Flask等web框架展示项目成果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "273.2px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
